/*
 * Solapas.cpp
 *
 *  Created on: 06/11/2011
 *      Author: edgardo
 */
#include <iostream>
#include <fstream>

#include "Solapas.h"
#include "ModelEstatico.h"
#include "ModelDinamico.h"
#include "ModelUsuarioclave.h"
#include "ModelError.h"

Solapas::Solapas(BaseObjectType* cobject,
		const Glib::RefPtr<Gtk::Builder>& refGlade) :
	Gtk::Notebook(cobject), builder(refGlade) {

	solapasVisibles = false;
	this->set_show_tabs(solapasVisibles);
	cargarWidgets();
	conectarEventos();
	inicializarDialogos();
	cargarBarraDeHerramientasTexto();

	builder->get_widget_derived("vbReporteAcceso", viewTextAcceso);
	builder->get_widget_derived("vbReporteError", viewTextError);
	setModoTexto(false);
}

Solapas::~Solapas() {
	// TODO Auto-generated destructor stub
}

int stringToInt(const std::string& cadena) {
	int auxEntero;
	std::stringstream auxStream;

	auxStream.clear();
	auxStream << cadena;
	auxStream >> auxEntero;
	return auxEntero;
}

void Solapas::cambiarVisibilidadSolapas() {
	solapasVisibles = !solapasVisibles;
	this->set_show_tabs(solapasVisibles);
}

void Solapas::inicializarDialogos() {
	builder->get_widget("dialogEstatico", dialogEstatico);
	builder->get_widget("dialogDinamico", dialogDinamico);
	builder->get_widget("dialogError", dialogError);
	builder->get_widget("dialogUsuario", dialogUsuario);

	dialogEstatico->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogEstatico->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

	dialogDinamico->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogDinamico->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

	dialogError->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogError->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

	dialogUsuario->add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialogUsuario->add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
}

void Solapas::conectarEventos() {
	Gtk::Button *btnAgregarUsuario;
	Gtk::Button *btnEliminarUsuario;
	Gtk::Button *btnModifUsuario;

	Gtk::Button *btnAgregarError;
	Gtk::Button *btnEliminarError;
	Gtk::Button *btnModifError;

	Gtk::Button *btnAgregarEstatico;
	Gtk::Button *btnEliminarEstatico;
	Gtk::Button *btnModifEstatico;

	Gtk::Button *btnAgregarDinamico;
	Gtk::Button *btnEliminarDinamico;
	Gtk::Button *btnModifDinamico;

	Gtk::Button *btnExaminar;
	Gtk::Button *btnExaminarRaiz;

	Gtk::Button *btnExaminarLogAccesos;
	Gtk::Button *btnExaminarLogErrores;

	builder->get_widget("btnAgregarUsuario", btnAgregarUsuario);
	builder->get_widget("btnEliminarUsuario", btnEliminarUsuario);
	builder->get_widget("btnModifUsuario", btnModifUsuario);

	builder->get_widget("btnAgregarError", btnAgregarError);
	builder->get_widget("btnEliminarError", btnEliminarError);
	builder->get_widget("btnModifErro", btnModifError);

	builder->get_widget("btnAgregarEstatico", btnAgregarEstatico);
	builder->get_widget("btnEliminarEstatico", btnEliminarEstatico);
	builder->get_widget("btnModifEstatico", btnModifEstatico);

	builder->get_widget("btnAgregarDinamico", btnAgregarDinamico);
	builder->get_widget("btnEliminarDinamico", btnEliminarDinamico);
	builder->get_widget("btnModifDinamico", btnModifDinamico);

	builder->get_widget("btnExaminar", btnExaminar);
	builder->get_widget("btnExaminarRaiz", btnExaminarRaiz);

	builder->get_widget("btnExaminarLogAccesos", btnExaminarLogAccesos);
	builder->get_widget("btnExaminarLogErrores", btnExaminarLogErrores);

	btnAgregarUsuario->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnAgregarUsuario));
	btnModifUsuario->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnModifUsuario));
	btnEliminarUsuario->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnEliminarUsuario));

	btnAgregarError->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnAgregarError));
	btnModifError->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnModifError));
	btnEliminarError->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnEliminarError));

	btnAgregarDinamico->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnAgregarDinamico));
	btnModifDinamico->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnModifDinamico));
	btnEliminarDinamico->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnEliminarDinamico));

	btnAgregarEstatico->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnAgregarEstatico));
	btnModifEstatico->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnModifEstatico));
	btnEliminarEstatico->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnEliminarEstatico));

	btnExaminar->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnExaminar));

	btnExaminarRaiz->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnExaminarRaiz));

	btnExaminarLogAccesos->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnExaminarLogAccesos));

	btnExaminarLogErrores->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_btnExaminarLogErrores));

}

void Solapas::on_click_btnExaminarLogAccesos() {
	Gtk::Entry* txtPathLogAccesos;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);
	builder->get_widget("txtPathLogAccesos", txtPathLogAccesos);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();
	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtPathLogAccesos->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::on_click_btnExaminarLogErrores() {
	Gtk::Entry* txtPathLogError;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);
	builder->get_widget("txtPathLogError", txtPathLogError);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();
	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtPathLogError->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::on_click_btnExaminar() {
	Gtk::Entry* txtPathError;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_OPEN);
	builder->get_widget("txtPathError", txtPathError);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();
	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtPathError->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		barraEstado->push("Carga de configuracion cancelada");
		break;
	}
	default: {
		break;
	}
	}
}

/**/
void Solapas::on_click_btnExaminarRaiz() {
	Gtk::Entry* txtRaiz;
	Gtk::FileChooserDialog dialog("Seleccionar archivo",
			Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
	builder->get_widget("txtRaiz", txtRaiz);
	//	dialog.set_transient_for(*ventanaPpal);
	dialog.set_transient_for(*ventanaPpal);

	// Agrego los botones para la respuesta:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialog.run();

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		std::string filename = dialog.get_filename();
		txtRaiz->set_text(filename);
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::on_click_btnAgregarUsuario() {
	Gtk::Entry* txtNombre;
	Gtk::Entry* txtClave;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogUsuario->run();
	builder->get_widget("txtNombre", txtNombre);
	builder->get_widget("txtClave", txtClave);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarUsuario(txtNombre->get_text(), txtClave->get_text());
		txtNombre->set_text("");
		txtClave->set_text("");
		dialogUsuario->hide();
		barraEstado->push("Se agrego el usuario");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtNombre->set_text("");
		txtClave->set_text("");
		dialogUsuario->hide();
		barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::agregarTipoEstatico(const std::string &extension,
		const std::string &contenido) {

	ModelEstatico modelEstatico;
	Glib::RefPtr < Gtk::ListStore > listTipoEstatico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore1"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listTipoEstatico->append());
	row[modelEstatico.Extension] = extension;
	row[modelEstatico.Contenido] = contenido;
}

void Solapas::agregarTipoDinamico(const std::string &extension,
		const std::string &comando) {

	ModelEstatico modelDinamico;
	Glib::RefPtr < Gtk::ListStore > listTipoDinamico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore2"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listTipoDinamico->append());
	row[modelDinamico.Extension] = extension;
	row[modelDinamico.Contenido] = comando;
}

void Solapas::agregarUsuario(const std::string &nombre,
		const std::string &clave) {

	ModelUsuarioClave modelUsuario;
	Glib::RefPtr < Gtk::ListStore > listUsuario
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore4"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listUsuario->append());
	row[modelUsuario.Usuario] = nombre;
	row[modelUsuario.Clave] = clave;
}

void Solapas::agregarError(const std::string &nroError, const std::string &path) {

	ModelError modelError;
	Glib::RefPtr < Gtk::ListStore > listError
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore3"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	Gtk::TreeModel::Row row = *(listError->append());
	row[modelError.NroError] = nroError;
	row[modelError.Path] = path;
}

void Solapas::on_click_btnModifUsuario() {
	Gtk::TreeView* tvUsuario;
	Gtk::Entry* txtNombre;
	Gtk::Entry* txtClave;

	Gtk::TreeModel::iterator iter;
	Glib::ustring nombre;
	Glib::ustring clave;
	Glib::RefPtr < Gtk::ListStore > listUsuario;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelUsuarioClave modelUsuario;

	builder->get_widget("tvUsuario", tvUsuario);
	builder->get_widget("txtNombre", txtNombre);
	builder->get_widget("txtClave", txtClave);

	listUsuario = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore1"));

	refSelection = tvUsuario->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nombre = ((*iter)[modelUsuario.Usuario]);
			clave = ((*iter)[modelUsuario.Clave]);

			txtNombre->set_text(nombre);
			txtClave->set_text(clave);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogUsuario->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				barraEstado->push("Aceptar");
				((*iter)[modelUsuario.Usuario]) = txtNombre->get_text();
				((*iter)[modelUsuario.Clave]) = txtClave->get_text();
				txtNombre->set_text("");
				txtClave->set_text("");
				txtNombre->set_text("");
				txtClave->set_text("");
				dialogUsuario->hide();
				barraEstado->push("Se modifico correctamente el usuario");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtNombre->set_text("");
				txtClave->set_text("");
				dialogUsuario->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void Solapas::on_click_btnEliminarUsuario() {
	Gtk::TreeView* tvUsuario;
	Glib::ustring nombre;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listUsuario;
	Gtk::TreeModel::iterator iter;
	ModelUsuarioClave modelUsuario;

	builder->get_widget("tvUsuario", tvUsuario);
	listUsuario = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore4"));

	refSelection = tvUsuario->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nombre = ((*iter)[modelUsuario.Usuario]);
			listUsuario->erase(iter);
			barraEstado->push("Se elimino: " + nombre);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}
}

void Solapas::on_click_btnAgregarError() {
	Gtk::Entry* txtNroError;
	Gtk::Entry* txtPathError;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogError->run();
	builder->get_widget("txtNroError", txtNroError);
	builder->get_widget("txtPathError", txtPathError);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarError(txtNroError->get_text(), txtPathError->get_text());
		txtNroError->set_text("");
		txtPathError->set_text("");
		dialogError->hide();
		barraEstado->push("Se agrego el error");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtNroError->set_text("");
		txtPathError->set_text("");
		dialogError->hide();
		//barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::on_click_btnModifError() {
	Gtk::TreeView* tvError;
	Gtk::Entry* txtNroError;
	Gtk::Entry* txtPathError;

	Gtk::TreeModel::iterator iter;
	Glib::ustring nroError;
	Glib::ustring pathError;
	Glib::RefPtr < Gtk::ListStore > listError;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelError modelError;

	builder->get_widget("txtNroError", txtNroError);
	builder->get_widget("txtPathError", txtPathError);
	builder->get_widget("tvError", tvError);

	listError = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore3"));

	refSelection = tvError->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nroError = ((*iter)[modelError.NroError]);
			pathError = ((*iter)[modelError.Path]);
			txtNroError->set_text(nroError);
			txtPathError->set_text(pathError);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogError->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				((*iter)[modelError.NroError]) = txtNroError->get_text();
				((*iter)[modelError.Path]) = txtPathError->get_text();
				txtNroError->set_text("");
				txtPathError->set_text("");
				dialogError->hide();
				barraEstado->push("Se modifico correctamente el tipo error");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtNroError->set_text("");
				txtPathError->set_text("");
				dialogError->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void Solapas::on_click_btnEliminarError() {
	Gtk::TreeView* tvError;
	Glib::ustring nroError;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listError;
	Gtk::TreeModel::iterator iter;
	ModelError modelError;

	builder->get_widget("tvError", tvError);
	listError = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore3"));

	refSelection = tvError->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			nroError = ((*iter)[modelError.NroError]);
			listError->erase(iter);
			barraEstado->push("Se elimino: " + nroError);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}
}

void Solapas::on_click_btnAgregarDinamico() {
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtComando;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogDinamico->run();
	builder->get_widget("txtExtensionDi", txtExtension);
	builder->get_widget("txtComando", txtComando);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarTipoDinamico(txtExtension->get_text(), txtComando->get_text());
		txtExtension->set_text("");
		txtComando->set_text("");
		dialogDinamico->hide();
		barraEstado->push("Se agrego el tipo dinamico");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtExtension->set_text("");
		txtComando->set_text("");
		dialogDinamico->hide();
		barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::on_click_btnModifDinamico() {
	Gtk::TreeView* tvDinamico;
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtComando;

	Gtk::TreeModel::iterator iter;
	Glib::ustring extension;
	Glib::ustring comando;
	Glib::RefPtr < Gtk::ListStore > listDinamico;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelDinamico modelDinamico;

	builder->get_widget("txtExtensionDi", txtExtension);
	builder->get_widget("txtComando", txtComando);
	builder->get_widget("tvDinamico", tvDinamico);

	listDinamico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore2"));

	refSelection = tvDinamico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelDinamico.Extension]);
			comando = ((*iter)[modelDinamico.Comando]);

			txtExtension->set_text(extension);
			txtComando->set_text(comando);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogDinamico->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				((*iter)[modelDinamico.Extension]) = txtExtension->get_text();
				((*iter)[modelDinamico.Comando]) = txtComando->get_text();
				txtExtension->set_text("");
				txtComando->set_text("");
				dialogDinamico->hide();
				barraEstado->push("Se modifico correctamente el tipo dinamico");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtExtension->set_text("");
				txtComando->set_text("");
				dialogDinamico->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void Solapas::on_click_btnEliminarDinamico() {
	Gtk::TreeView* tvDinamico;
	Glib::ustring extension;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listDinamico;
	Gtk::TreeModel::iterator iter;
	ModelDinamico modelDinamico;

	builder->get_widget("tvDinamico", tvDinamico);
	listDinamico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore2"));

	refSelection = tvDinamico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelDinamico.Extension]);
			listDinamico->erase(iter);
			barraEstado->push("Se elimino: " + extension);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}

}

void Solapas::on_click_btnAgregarEstatico() {
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtContenido;

	// Muestro el dialogo y espero hasta que elija una opcion.
	int result = dialogEstatico->run();
	builder->get_widget("txtExtensionEs", txtExtension);
	builder->get_widget("txtContenido", txtContenido);

	// Reviso el resultado.
	switch (result) {
	case (Gtk::RESPONSE_OK): {
		agregarTipoEstatico(txtExtension->get_text(), txtContenido->get_text());
		txtExtension->set_text("");
		txtContenido->set_text("");
		dialogEstatico->hide();
		barraEstado->push("Se agrego el tipo estatico");
		break;
	}
	case (Gtk::RESPONSE_CANCEL): {
		txtExtension->set_text("");
		txtContenido->set_text("");
		dialogEstatico->hide();
		barraEstado->push("Cancelar");
		break;
	}
	default: {
		break;
	}
	}
}

void Solapas::on_click_btnModifEstatico() {
	Gtk::TreeView* tvEstatico;
	Gtk::Entry* txtExtension;
	Gtk::Entry* txtContenido;
	Gtk::TreeModel::iterator iter;
	Glib::ustring extension;
	Glib::ustring contenido;
	Glib::RefPtr < Gtk::ListStore > listEstatico;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	ModelEstatico modelEstatico;

	builder->get_widget("tvEstatico", tvEstatico);
	builder->get_widget("txtExtensionEs", txtExtension);
	builder->get_widget("txtContenido", txtContenido);

	listEstatico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore1"));

	refSelection = tvEstatico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelEstatico.Extension]);
			contenido = ((*iter)[modelEstatico.Contenido]);

			txtExtension->set_text(extension);
			txtContenido->set_text(contenido);

			// Muestro el dialogo y espero hasta que elija una opcion.
			int result = dialogEstatico->run();

			// Reviso el resultado.
			switch (result) {
			case (Gtk::RESPONSE_OK): {
				barraEstado->push("Aceptar");
				((*iter)[modelEstatico.Extension]) = txtExtension->get_text();
				((*iter)[modelEstatico.Contenido]) = txtContenido->get_text();
				txtExtension->set_text("");
				txtContenido->set_text("");
				dialogEstatico->hide();
				barraEstado->push("Se modifico correctamente el tipo estatico");
				break;
			}
			case (Gtk::RESPONSE_CANCEL): {
				txtExtension->set_text("");
				txtContenido->set_text("");
				dialogEstatico->hide();
				barraEstado->push("Cancelar");
				break;
			}
			default: {
				//barraEstado->push("que??");
				break;
			}
			}
		}
	}
	//barraEstado->push("Seleccionar una fila para modificar");
}

void Solapas::on_click_btnEliminarEstatico() {
	Gtk::TreeView* tvEstatico;
	Glib::ustring extension;
	Glib::RefPtr < Gtk::TreeView::Selection > refSelection;
	Glib::RefPtr < Gtk::ListStore > listEstatico;
	Gtk::TreeModel::iterator iter;
	ModelEstatico modelEstatico;

	builder->get_widget("tvEstatico", tvEstatico);
	listEstatico = Glib::RefPtr<Gtk::ListStore>::cast_static(
			builder->get_object("liststore1"));

	refSelection = tvEstatico->get_selection();

	if (refSelection) {
		iter = refSelection->get_selected();
		if (iter) {
			extension = ((*iter)[modelEstatico.Extension]);
			listEstatico->erase(iter);
			barraEstado->push("Se elimino: " + extension);
		} else
			barraEstado->push("Seleccionar una fila para eliminar");
	}
}

void Solapas::cargarWidgets() {
	builder->get_widget("barraEstado", barraEstado);
}

void Solapas::setConfiguracionBasica(const ConfiguracionBasica& confBasica) {
	std::stringstream auxStream;
	Gtk::SpinButton* sbtPuerto;
	Gtk::SpinButton* sbtPuertoContro;
	Gtk::SpinButton* sbtMaxConexiones;
	Gtk::SpinButton* sbtMaxConCliente;
	Gtk::SpinButton* sbtTimeOut;
	Gtk::Entry* txtRaiz;
	Gtk::CheckButton* cbtProtegido;

	builder->get_widget("sbtPuerto", sbtPuerto);
	builder->get_widget("sbtPuertoContro", sbtPuertoContro);
	builder->get_widget("txtRaiz", txtRaiz);
	builder->get_widget("cbtProtegido", cbtProtegido);
	builder->get_widget("sbtMaxConexiones", sbtMaxConexiones);
	builder->get_widget("sbtMaxConCliente", sbtMaxConCliente);
	builder->get_widget("sbtTimeOut", sbtTimeOut);

	sbtPuerto->set_value(confBasica.getPuerto());
	sbtPuertoContro->set_value(confBasica.getPuertoControl());
	sbtMaxConexiones->set_value(confBasica.getMaximoConexiones());
	sbtMaxConCliente->set_value(confBasica.getMaximoConexionesCliente());
	sbtTimeOut->set_value(confBasica.getTimeOut());
	txtRaiz->set_text(confBasica.getRaiz());

	//	confBasica.setPuertoControl(sbtPuertoContro->get_value());
	//	confBasica.setMaximoConexiones(sbtMaxConexiones->get_value());
	//	confBasica.setMaximoConexionesCliente(sbtMaxConCliente->get_value());
	//	confBasica.setTimeOut(sbtTimeOut->get_value());
	//	confBasica.setRaiz(txtRaiz->get_text());

	cbtProtegido->set_active(confBasica.getProteccion());

}

void Solapas::setConfiguracionEstatico(std::list<TipoEstatico> configuracion) {
	std::list<TipoEstatico>::iterator it = configuracion.begin();

	ModelEstatico modelEstatico;
	Glib::RefPtr < Gtk::ListStore > listTipoEstatico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore1"));
	listTipoEstatico->clear();

	while (it != configuracion.end()) {
		agregarTipoEstatico(it->getExtension(), it->getContenido());
		it++;
	}
}

void Solapas::setConfiguracionDinamico(std::list<TipoDinamico> configuracion) {
	std::list<TipoDinamico>::iterator it = configuracion.begin();

	ModelEstatico modelDinamico;
	Glib::RefPtr < Gtk::ListStore > listTipoDinamico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore2"));
	listTipoDinamico->clear();

	while (it != configuracion.end()) {
		agregarTipoDinamico(it->getExtension(), it->getComando());
		it++;
	}
}

void Solapas::setConfiguracionUsuario(std::list<Usuario> configuracion) {
	std::list<Usuario>::iterator it = configuracion.begin();

	ModelUsuarioClave modelUsuario;
	Glib::RefPtr < Gtk::ListStore > listUsuario
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore4"));

	listUsuario->clear();

	while (it != configuracion.end()) {
		agregarUsuario(it->getNombre(), it->getClave());
		it++;
	}
}
void Solapas::setConfiguracionReportes(ConfiguracionLogs confLog) {
	Gtk::Entry* pathReporteError;
	Gtk::Entry* pathReporteAccesos;

	builder->get_widget("txtPathLogAccesos", pathReporteAccesos);
	builder->get_widget("txtPathLogError", pathReporteError);

	pathReporteAccesos->set_text(confLog.getRutaLogAccesos());
	pathReporteError->set_text(confLog.getRutaLogErrores());
}

void Solapas::setConfiguracionErrores(std::list<TipoError> configuracion) {
	std::list<TipoError>::iterator it = configuracion.begin();

	ModelError modelError;
	Glib::RefPtr < Gtk::ListStore > listError
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore3"));
	listError->clear();

	while (it != configuracion.end()) {
		std::stringstream nroError;
		nroError << it->getNroError();
		agregarError(nroError.str(), it->getRuta());
		it++;
		//nroError.clear();
	}

	//void VentanaPrincipal::agregarError(const std::string &nroError, const std::string &path) {

}

void Solapas::agregarConfiguracionBasica(Configuracion& configuracion) {
	std::stringstream auxStream;
	Gtk::SpinButton* sbtPuerto;
	Gtk::SpinButton* sbtPuertoContro;
	Gtk::SpinButton* sbtMaxConexiones;
	Gtk::SpinButton* sbtMaxConCliente;
	Gtk::SpinButton* sbtTimeOut;
	Gtk::Entry* txtRaiz;
	Gtk::CheckButton* cbtProtegido;

	builder->get_widget("sbtPuerto", sbtPuerto);
	builder->get_widget("sbtPuertoContro", sbtPuertoContro);
	builder->get_widget("txtRaiz", txtRaiz);
	builder->get_widget("cbtProtegido", cbtProtegido);
	builder->get_widget("sbtMaxConexiones", sbtMaxConexiones);
	builder->get_widget("sbtMaxConCliente", sbtMaxConCliente);
	builder->get_widget("sbtTimeOut", sbtTimeOut);

	ConfiguracionBasica confBasica;
	confBasica.setPuerto(sbtPuerto->get_value());
	confBasica.setPuertoControl(sbtPuertoContro->get_value());
	confBasica.setMaximoConexiones(sbtMaxConexiones->get_value());
	confBasica.setMaximoConexionesCliente(sbtMaxConCliente->get_value());
	confBasica.setTimeOut(sbtTimeOut->get_value());
	confBasica.setRaiz(txtRaiz->get_text());

	if (cbtProtegido->get_active())
		confBasica.proteger();

	configuracion.setConfiguracionBasica(confBasica);
}

void Solapas::agregarConfiguracionEstatico(Configuracion& configuracion) {
	TipoEstatico* confEstatico;
	Glib::ustring extension;
	Glib::ustring contenido;

	Glib::RefPtr < Gtk::ListStore > listTipoEstatico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore1"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelEstatico modelEstatico;

	type_children children = listTipoEstatico->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		extension = (*iter)[modelEstatico.Extension];
		contenido = (*iter)[modelEstatico.Contenido];
		confEstatico = new TipoEstatico();
		confEstatico->setExtension(extension);
		confEstatico->setContenido(contenido);
		configuracion.agregarTipoEstatico(confEstatico);
	}
}

void Solapas::agregarConfiguracionDinamico(Configuracion& configuracion) {
	TipoDinamico* confDinamico;
	Glib::ustring extension;
	Glib::ustring comando;

	Glib::RefPtr < Gtk::ListStore > listTipoDinamico = Glib::RefPtr<
			Gtk::ListStore>::cast_static(builder->get_object("liststore2"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelDinamico modelDinamico;

	type_children children = listTipoDinamico->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		extension = (*iter)[modelDinamico.Extension];
		comando = (*iter)[modelDinamico.Comando];
		confDinamico = new TipoDinamico();
		confDinamico->setExtension(extension);
		confDinamico->setComando(comando);
		configuracion.agregarTipoDinamico(confDinamico);
	}
}

void Solapas::agregarConfiguracionUsuario(Configuracion& configuracion) {
	Usuario* confUsuario;
	Glib::ustring nombre;
	Glib::ustring clave;

	Glib::RefPtr < Gtk::ListStore > listUsuarios
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore4"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelUsuarioClave modelUsuarioClave;

	type_children children = listUsuarios->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		nombre = (*iter)[modelUsuarioClave.Usuario];
		clave = (*iter)[modelUsuarioClave.Clave];
		confUsuario = new Usuario();
		confUsuario->setNombre(nombre);
		confUsuario->setClave(clave);
		configuracion.agregarUsuario(confUsuario);
	}
}

void Solapas::agregarConfiguracionErrores(Configuracion& configuracion) {
	Glib::ustring nroError;
	Glib::ustring path;
	int nroErrorEntero;

	Glib::RefPtr < Gtk::ListStore > listUsuarios
			= Glib::RefPtr<Gtk::ListStore>::cast_static(
					builder->get_object("liststore3"));

	typedef Gtk::TreeModel::Children type_children; //minimise code length.
	ModelError modelError;

	type_children children = listUsuarios->children();
	for (type_children::iterator iter = children.begin(); iter
			!= children.end(); ++iter) {
		Gtk::TreeModel::Row row = *iter;
		nroError = (*iter)[modelError.NroError];
		path = (*iter)[modelError.Path];
		nroErrorEntero = stringToInt(nroError);
		TipoError* tipoError = new TipoError();
		tipoError->setNroError(nroErrorEntero);
		tipoError->setRuta(path);
		configuracion.agregarError(tipoError);
	}
}

void Solapas::agregarConfiguracionReportes(Configuracion& configuracion) {
	Gtk::Entry* pathReporteError;
	Gtk::Entry* pathReporteAccesos;

	builder->get_widget("txtPathLogAccesos", pathReporteAccesos);
	builder->get_widget("txtPathLogError", pathReporteError);

	ConfiguracionLogs confLogs;
	confLogs.setRutaLogAccesos(pathReporteAccesos->get_text());
	confLogs.setRutaLogErrores(pathReporteError->get_text());
	configuracion.setConfiguracionLogs(confLogs);
}

void Solapas::cargarConfiguracion(Configuracion& config) {

	setConfiguracionBasica(config.getConfiguracionBasica());
	setConfiguracionEstatico(config.getTiposEstaticos());
	setConfiguracionDinamico(config.getTiposDinamicos());
	setConfiguracionUsuario(config.getUsuarios());
	setConfiguracionErrores(config.getTiposErrores());
	setConfiguracionReportes(config.getConfiguracionLogs());
}

void Solapas::guardarConfiguracion(const std::string &rutaArchivo) {
	Configuracion configuracion;

	agregarConfiguracionBasica(configuracion);
	agregarConfiguracionEstatico(configuracion);
	agregarConfiguracionDinamico(configuracion);
	agregarConfiguracionErrores(configuracion);
	agregarConfiguracionReportes(configuracion);
	agregarConfiguracionUsuario(configuracion);
	configuracion.guardarComo(rutaArchivo);

}

void Solapas::setModoTexto(bool estado) {
	Gtk::Toolbar* barraTexto;
	builder->get_widget("barraTexto", barraTexto);
	if (estado)
		barraTexto->show();
	else
		barraTexto->hide();
}

void Solapas::on_click_IrAlFinal() {
	int opcion = this->get_current_page();
	if (opcion == 6) {
		viewTextError->irAlfinal();
		barraEstado->push("Ir al final en Errores");
	} else if (opcion == 7) {
		viewTextAcceso->irAlfinal();
		barraEstado->push("Ir al final en Accessos");
	} else
		barraEstado->push("No entiendo!");
}

void Solapas::on_click_CerrarBusquedaError() {
	viewTextError->ocultarBarra();
}

void Solapas::on_click_CerrarBusquedaAcceso() {
	viewTextAcceso->ocultarBarra();
}

void Solapas::on_click_Buscar() {
	int opcion = this->get_current_page();
	if (opcion == 6) {
		viewTextError->mostrarBarra();
		barraEstado->push("Mostrar barra de buqueda Errores");
	} else if (opcion == 7) {
		viewTextAcceso->mostrarBarra();
		barraEstado->push("Mostrar barra de buqueda en Accessos");
	} else
		barraEstado->push("No entiendo!");
}

void Solapas::on_click_Actualizar() {
	int opcion = this->get_current_page();
	if (opcion == 6) {
		viewTextError->cargarReporte();
		barraEstado->push("Se actualizo el reporte de error");
	} else if (opcion == 7) {
		viewTextAcceso->cargarReporte();
		barraEstado->push("Se actualizo el reporte de accesos");
	} else
		barraEstado->push("No entiendo!");
}

void Solapas::cargarBarraDeHerramientasTexto() {
	Gtk::ToolButton * toolbtBuscar;
	Gtk::ToolButton * toolbtIrAlFinal;
	Gtk::ToolButton * toolbtActualizar;
	Gtk::Button *btnCerrarBusquedaAcceso;
	Gtk::Button *btnCerrarBusquedaError;

	builder->get_widget("toolbtBuscar", toolbtBuscar);
	builder->get_widget("toolbtIrAlFinal", toolbtIrAlFinal);
	builder->get_widget("toolbtActualizar", toolbtActualizar);
	builder->get_widget("btnCerrarBusquedaAcceso", btnCerrarBusquedaAcceso);
	builder->get_widget("btnCerrarBusquedaError", btnCerrarBusquedaError);

	toolbtIrAlFinal->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_IrAlFinal));

	toolbtBuscar->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_Buscar));

	toolbtActualizar->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_Actualizar));

	btnCerrarBusquedaAcceso->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_CerrarBusquedaAcceso));

	btnCerrarBusquedaError->signal_clicked().connect(
			sigc::mem_fun(*this, &Solapas::on_click_CerrarBusquedaError));

	setModoTexto(false);
}

void Solapas::setVentanaPpal(Gtk::Window *ventana) {
	this->ventanaPpal = ventana;
}

void Solapas::cargarReporte(int numeroReporte) {
	std::ifstream archivoError;
	switch (numeroReporte) {
	case SOLAPA_REPORTE_ERROR:
		viewTextError->cargarReporte();
		setModoTexto(true);
		break;
	case SOLAPA_REPORTE_ACCESO:
		viewTextAcceso->cargarReporte();
		setModoTexto(true);
		break;
	default:
		setModoTexto(false);
		break;
	}
}

bool Solapas::on_button_press_event(GdkEventButton* event) {
	bool res = Gtk::Notebook::on_button_press_event(event);
	int opcion = this->get_current_page();
	cargarReporte(opcion);
	return res;
}

void Solapas::set_current_page(int numero) {
	cargarReporte(numero);
	Gtk::Notebook::set_current_page(numero);
}
